// 标签管理器 - 处理问卷结果对应的用户标签
import { getQuestionnaire, getAssessResult } from './schema-loader.js'
import tagConfigs from '@/static/questionnaire/tag_configs.json'

/**
 * 标签管理器
 * 处理问卷结果对应的用户标签
 */
export class TagManager {
    constructor() {
        this.tagConfigs = new Map();
        this.loadTagConfigs();
    }

    /**
     * 从问卷配置中加载标签配置
     */
    loadTagConfigs() {
        try {
            // 加载 Screening 配置
            const screeningConfig = getQuestionnaire('screening');
            if (screeningConfig && screeningConfig.score_judge) {
                this.tagConfigs.set('screening', {
                    generateTags: (results) => this.generateScreeningTags(results, screeningConfig.score_judge)
                });
            }

            // 加载 Assessment 配置
            const assessResultConfig = getAssessResult();
            if (assessResultConfig) {
                this.tagConfigs.set('assessment', {
                    generateTags: (results) => this.generateAssessmentTags(results, assessResultConfig)
                });
            }

            // 加载 Healthtest 配置
            const h1Config = getQuestionnaire('h1_important_effect');
            if (h1Config) {
                this.tagConfigs.set('healthtest', {
                    generateTags: (results) => this.generateHealthtestTags(results, h1Config)
                });
            }

            console.log('Tag configurations loaded successfully');
        } catch (e) {
            console.error('Failed to load tag configurations:', e);
        }
    }

    /**
     * 生成 Screening 标签
     * @param {Array} results - 筛查结果
     * @param {Array} scoreJudge - 评分判断配置
     * @returns {Array} 标签数组
     */
    generateScreeningTags(results, scoreJudge) {
        const tags = [];
        for (const result of results) {
            // 查找对应的 score_judge 配置
            const judgeConfig = scoreJudge.find(judge => judge.assessment === result.assessment);
            if (judgeConfig && judgeConfig.tag_rules) {
                // 根据 risk 值匹配对应的标签
                const tagRule = judgeConfig.tag_rules.find(rule => rule.risk === result.risk);
                if (tagRule) {
                    tags.push(tagRule.tag);
                }
            }
        }
        return tags;
    }

    /**
     * 生成 Assessment 标签
     * @param {Object} results - 评估结果
     * @param {Object} assessResultConfig - 评估结果配置
     * @returns {Array} 标签数组
     */
    generateAssessmentTags(results, assessResultConfig) {
        const tags = [];

        for (const [dimension, result] of Object.entries(results)) {
            if (!result) continue;

            const dimensionConfig = assessResultConfig[dimension];
            if (!dimensionConfig) continue;

            // 遍历该维度的所有子模块
            for (const subKey of dimensionConfig.submodule_keys) {
                const submodule = dimensionConfig.submodules[subKey];
                const subResult = result[subKey];
                let value = null;
                if (subResult && typeof subResult === 'object') {
                    if (Object.prototype.hasOwnProperty.call(subResult, 'value')) {
                        value = subResult.value; // compressed format
                    } else if (subResult.result && Object.prototype.hasOwnProperty.call(subResult.result, 'value')) {
                        value = subResult.result.value; // uncompressed format
                    }
                }
                if (value == null) value = submodule.default;

                // 查找对应的 value 配置
                const valueConfig = submodule.values.find(v => v.value === value);
                if (valueConfig && valueConfig.tag) {
                    tags.push(valueConfig.tag);
                }
            }
        }

        return tags;
    }

    /**
     * 生成 Healthtest 标签
     * @param {Object} results - 健康测试结果
     * @param {Object} h1Config - h1问卷配置
     * @returns {Array} 标签数组
     */
    generateHealthtestTags(results, h1Config) {
        const tags = [];

        // 只处理h1的结果，因为h2不产生标签
        if (!results.h1) return tags;

        // 从结果中收集标签
        for (const [key, item] of Object.entries(results.h1)) {
            if (item.result?.tag) {
                tags.push(item.result.tag);
            }
        }

        return tags;
    }

    /**
     * 生成标签
     * @param {string} questionnaireType - 问卷类型
     * @param {*} results - 问卷结果
     * @returns {Array} 标签数组
     */
    generateTags(questionnaireType, results) {
        const config = this.tagConfigs.get(questionnaireType);
        if (!config || !config.generateTags) return [];

        return config.generateTags(results);
    }

    /**
     * 获取标签的中文显示名称
     * @param {string} tagKey - 标签键
     * @returns {string} 中文显示名称
     */
    getTagDisplayName(tagKey) {
        if (tagConfigs && tagConfigs.tags && tagConfigs.tags[tagKey] && tagConfigs.tags[tagKey].cn) {
            return tagConfigs.tags[tagKey].cn;
        }
        return tagKey;
    }

    /**
     * 获取标签的英文名称
     * @param {string} tagKey - 标签键
     * @returns {string} 英文名称
     */
    getTagEnglishName(tagKey) {
        if (tagConfigs && tagConfigs.tags && tagConfigs.tags[tagKey] && tagConfigs.tags[tagKey].en) {
            return tagConfigs.tags[tagKey].en;
        }
        return tagKey;
    }
}

// 创建全局实例
const tagManager = new TagManager();

/**
 * 生成标签
 * @param {string} type - 问卷类型
 * @param {*} results - 问卷结果
 * @returns {Array} 标签数组
 */
export const generateTags = (type, results) => tagManager.generateTags(type, results);

/**
 * 获取标签的中文显示名称
 * @param {string} tagKey - 标签键
 * @returns {string} 中文显示名称
 */
export const getTagDisplayName = (tagKey) => tagManager.getTagDisplayName(tagKey);

/**
 * 获取标签的英文名称
 * @param {string} tagKey - 标签键
 * @returns {string} 英文名称
 */
export const getTagEnglishName = (tagKey) => tagManager.getTagEnglishName(tagKey);

/**
 * 获取标签配置
 * @returns {Object} 标签配置对象
 */
export const getTagConfig = () => {
    return tagConfigs;
};

export { tagManager };
